 
use std::any::Any;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};

/// 可销毁对象的 Trait，所有 Bean 都需要能够被销毁。
pub trait IDestructible {
    fn destructor(&self);
}

/// `BeanManager` 的核心，用于存储和检索 Bean 实例。
/// 我们使用 `Arc<Mutex<...>>` 来允许多线程安全地访问和修改 Bean 容器。
pub type BeanContainer = Arc<Mutex<HashMap<&'static str, Arc<dyn Any + Send + Sync>>>>;

/// Bean 管理器，我们的 DI 容器。
pub struct BeanManager {
    /// 存储所有已创建的 Bean 实例。
    beans: BeanContainer,
    /// 存储所有需要执行销毁逻辑的 Bean。
    destructibles: Arc<Mutex<Vec<Arc<dyn IDestructible + Send + Sync>>>>,
}

impl BeanManager {
    /// 创建一个新的 `BeanManager`。
    pub fn new(seeds: HashMap<&'static str, Arc<dyn Any + Send + Sync>>) -> Self {
        let beans = Arc::new(Mutex::new(seeds));
        Self {
            beans,
            destructibles: Arc::new(Mutex::new(Vec::new())),
        }
    }

    /// 初始化所有 Bean。在 `ai-server` 中，这会触发生命周期方法。
    /// 在我们的 Rust 实现中，`post_construct` 将在每个 Bean 的 `new` 方法中被调用。
    pub fn init(&self) {
        // 在 Rust 中，依赖注入在构造时完成，所以 init 主要是为了符合 `ai-server` 的生命周期概念。
        // 真正的初始化逻辑在各个 Bean 的 `new` 方法中。
    }

    /// 销毁所有可销毁的 Bean。
    pub fn destructor(&self) {
        let destructibles = self.destructibles.lock().unwrap();
        for bean in destructibles.iter() {
            bean.destructor();
        }
    }

    /// 从容器中获取一个 Bean。
    /// 这是服务定位器模式的核心。
    pub fn get_bean<T: Any + Send + Sync>(&self, name: &str) -> Option<Arc<T>> {
        let beans = self.beans.lock().unwrap();
        beans.get(name).and_then(|bean| bean.clone().downcast::<T>().ok())
    }

    /// 向容器中添加一个 Bean。
    pub fn add_bean(&self, name: &'static str, bean: Arc<dyn Any + Send + Sync>) {
        let mut beans = self.beans.lock().unwrap();
        beans.insert(name, bean);
    }

    /// 注册一个可销毁的 Bean。
    pub fn add_destructible(&self, bean: Arc<dyn IDestructible + Send + Sync>) {
        let mut destructibles = self.destructibles.lock().unwrap();
        destructibles.push(bean);
    }

    /// 获取内部的 Bean 容器的克隆，用于构造函数注入。
    pub fn get_container(&self) -> BeanContainer {
        self.beans.clone()
    }
}

/// 为了模拟 `ai-server` 中 Bean 的生命周期和依赖注入，我们定义一个 `Bean` Trait。
/// 每个核心服务（Manager）都将实现这个 Trait。
pub trait Bean: IDestructible + Sized {
    /// Bean 的构造函数，接收 `BeanManager` 的引用以实现依赖注入。
    fn new(bean_manager: &Arc<BeanManager>) -> Arc<Self>;
}
